/*
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <http://www.gnu.org/licenses/>.
 */
/**
	coded by Balancer
	balancer@balancer.ru
	http://balancer.ru

	version 0.1, 2005-03-12
 */

package com.l2jserver.gameserver.model;

import java.util.List;
import java.util.logging.Logger;

import javolution.util.FastList;

import com.l2jserver.util.Rnd;

public class L2Territory
{
	private static Logger _log = Logger.getLogger(L2Territory.class.getName());
	
	protected static class Point
	{
		protected int _x, _y, _zmin, _zmax, _proc;
		
		Point(final int x, final int y, final int zmin, final int zmax, final int proc)
		{
			_x = x;
			_y = y;
			_zmin = zmin;
			_zmax = zmax;
			_proc = proc;
		}
	}
	
	private final List<Point> _points;
	private final int _terr;
	private int _xMin;
	private int _xMax;
	private int _yMin;
	private int _yMax;
	private int _zMin;
	private int _zMax;
	private int _procMax;
	
	public L2Territory(final int terr)
	{
		_points = new FastList<Point>();
		_terr = terr;
		_xMin = 999999;
		_xMax = -999999;
		_yMin = 999999;
		_yMax = -999999;
		_zMin = 999999;
		_zMax = -999999;
		_procMax = 0;
	}
	
	public void add(final int x, final int y, final int zmin, final int zmax, final int proc)
	{
		_points.add(new Point(x, y, zmin, zmax, proc));
		if (x < _xMin)
			_xMin = x;
		if (y < _yMin)
			_yMin = y;
		if (x > _xMax)
			_xMax = x;
		if (y > _yMax)
			_yMax = y;
		if (zmin < _zMin)
			_zMin = zmin;
		if (zmax > _zMax)
			_zMax = zmax;
		_procMax += proc;
	}
	
	public void print()
	{
		for (final Point p : _points)
			_log.info("(" + p._x + "," + p._y + ")");
	}
	
	public boolean isIntersect(final int x, final int y, final Point p1, final Point p2)
	{
		final double dy1 = p1._y - y;
		final double dy2 = p2._y - y;
		
		if (Math.signum(dy1) == Math.signum(dy2))
			return false;
		
		final double dx1 = p1._x - x;
		final double dx2 = p2._x - x;
		
		if (dx1 >= 0 && dx2 >= 0)
			return true;
		
		if (dx1 < 0 && dx2 < 0)
			return false;
		
		final double dx0 = dy1 * (p1._x - p2._x) / (p1._y - p2._y);
		
		return dx0 <= dx1;
	}
	
	public boolean isInside(final int x, final int y)
	{
		int intersect_count = 0;
		for (int i = 0; i < _points.size(); i++)
		{
			final Point p1 = _points.get(i > 0 ? i - 1 : _points.size() - 1);
			final Point p2 = _points.get(i);
			
			if (isIntersect(x, y, p1, p2))
				intersect_count++;
		}
		
		return intersect_count % 2 == 1;
	}
	
	public int[] getRandomPoint()
	{
		final int[] p = new int[4];
		if (_procMax > 0)
		{
			int pos = 0;
			final int rnd = Rnd.nextInt(_procMax);
			for (final Point p1 : _points)
			{
				pos += p1._proc;
				if (rnd <= pos)
				{
					p[0] = p1._x;
					p[1] = p1._y;
					p[2] = p1._zmin;
					p[3] = p1._zmax;
					return p;
				}
			}
			
		}
		for (int i = 0; i < 100; i++)
		{
			p[0] = Rnd.get(_xMin, _xMax);
			p[1] = Rnd.get(_yMin, _yMax);
			if (isInside(p[0], p[1]))
			{
				double curdistance = 0;
				p[2] = _zMin + 100;
				p[3] = _zMax;
				for (final Point p1 : _points)
				{
					final double dx = p1._x - p[0];
					final double dy = p1._y - p[1];
					final double distance = Math.sqrt(dx * dx + dy * dy);
					if (curdistance == 0 || distance < curdistance)
					{
						curdistance = distance;
						p[2] = p1._zmin + 100;
					}
				}
				return p;
			}
		}
		_log.warning("Can't make point for territory " + _terr);
		return p;
	}
	
	public int getProcMax()
	{
		return _procMax;
	}
}
